Argparse Python Tingkat Lanjut: Menguasai Subperintah dan Kelas Aksi Kustom

Modul argparse Python adalah alat yang ampuh untuk membuat antarmuka baris perintah (CLI). Meskipun penggunaan dasarnya relatif mudah, argparse menawarkan fitur-fitur canggih yang memungkinkan pembuatan CLI yang canggih dan ramah pengguna. Postingan blog ini membahas dua fitur canggih tersebut: subperintah dan kelas aksi kustom.

Mengapa Argparse Tingkat Lanjut?

Untuk skrip sederhana dengan hanya beberapa opsi, fungsionalitas argparse dasar mungkin sudah cukup. Namun, seiring pertumbuhan kompleksitas dan fungsionalitas skrip Anda, CLI yang lebih terstruktur dan terorganisir menjadi sangat penting. Fitur argparse tingkat lanjut membantu untuk:

• Meningkatkan Pengalaman Pengguna: Menyediakan antarmuka yang jelas dan intuitif bagi pengguna.
• Meningkatkan Kemampuan Pemeliharaan Kode: Mengorganisir kode Anda menjadi modul logis, membuatnya lebih mudah dipahami dan dipelihara.
• Meningkatkan Fungsionalitas: Mendukung alur kerja yang kompleks dan beberapa operasi dalam satu skrip.
• Meningkatkan Penggunaan Kembali: Membuat komponen yang dapat digunakan kembali yang dapat diterapkan ke berbagai bagian aplikasi Anda.

Subperintah: Mengorganisir CLI yang Kompleks

Subperintah adalah cara untuk mengelompokkan perintah terkait di bawah satu perintah utama. Ini sangat berguna untuk aplikasi yang melakukan berbagai tugas berbeda. Pikirkan Git, misalnya. Ia menggunakan subperintah secara ekstensif: git commit, git push, git pull, dan sebagainya. Setiap subperintah memiliki serangkaian argumen dan opsi sendiri.

Menerapkan Subperintah dengan argparse

Untuk menerapkan subperintah dengan argparse, Anda menggunakan metode add_subparsers(). Berikut adalah contoh dasar:

            
import argparse

# Buat parser utama
parser = argparse.ArgumentParser(description='Contoh sederhana dengan subperintah')

# Buat subparser
subparsers = parser.add_subparsers(dest='command', help='Perintah yang tersedia')

# Buat subperintah 'add'
add_parser = subparsers.add_parser('add', help='Tambahkan dua angka')
add_parser.add_argument('x', type=int, help='Angka pertama')
add_parser.add_argument('y', type=int, help='Angka kedua')

# Buat subperintah 'subtract'
subtract_parser = subparsers.add_parser('subtract', help='Kurangkan dua angka')
subtract_parser.add_argument('x', type=int, help='Angka pertama')
subtract_parser.add_argument('y', type=int, help='Angka kedua')

# Uraikan argumen
args = parser.parse_args()

# Lakukan aksi berdasarkan subperintah
if args.command == 'add':
    result = args.x + args.y
    print(f'Jumlahnya adalah: {result}')
elif args.command == 'subtract':
    result = args.x - args.y
    print(f'Selisihnya adalah: {result}')
else:
    parser.print_help()

            

              
                Copy
              
            
          

Dalam contoh ini:

• Kami membuat parser utama menggunakan argparse.ArgumentParser().
• Kami menambahkan subparser menggunakan parser.add_subparsers(dest='command', help='Perintah yang tersedia'). Argumen dest menentukan atribut yang akan menyimpan nama subperintah yang dipilih.
• Kami membuat dua subperintah, 'add' dan 'subtract', menggunakan subparsers.add_parser().
• Setiap subperintah memiliki serangkaian argumennya sendiri (x dan y).
• Kami menguraikan argumen menggunakan parser.parse_args().
• Kami memeriksa nilai args.command untuk menentukan subperintah mana yang dipilih dan kemudian melakukan aksi yang sesuai.

Untuk menjalankan skrip ini, Anda akan menggunakan perintah seperti:

python your_script.py add 5 3
python your_script.py subtract 10 2

Teknik Subperintah Tingkat Lanjut

1. Menggunakan Fungsi untuk Menangani Subperintah

Pendekatan yang lebih terorganisir adalah menentukan fungsi terpisah untuk menangani setiap subperintah. Ini meningkatkan keterbacaan dan kemampuan pemeliharaan kode.

            
import argparse

def add(args):
    result = args.x + args.y
    print(f'Jumlahnya adalah: {result}')

def subtract(args):
    result = args.x - args.y
    print(f'Selisihnya adalah: {result}')

# Buat parser utama
parser = argparse.ArgumentParser(description='Contoh sederhana dengan subperintah')

# Buat subparser
subparsers = parser.add_subparsers(dest='command', help='Perintah yang tersedia')

# Buat subperintah 'add'
add_parser = subparsers.add_parser('add', help='Tambahkan dua angka')
add_parser.add_argument('x', type=int, help='Angka pertama')
add_parser.add_argument('y', type=int, help='Angka kedua')
add_parser.set_defaults(func=add)

# Buat subperintah 'subtract'
subtract_parser = subparsers.add_parser('subtract', help='Kurangkan dua angka')
subtract_parser.add_argument('x', type=int, help='Angka pertama')
subtract_parser.add_argument('y', type=int, help='Angka kedua')
subtract_parser.set_defaults(func=subtract)

# Uraikan argumen
args = parser.parse_args()

# Panggil fungsi yang terkait dengan subperintah
if hasattr(args, 'func'):
    args.func(args)
else:
    parser.print_help()

            

              
                Copy
              
            
          

Di sini, kita menggunakan set_defaults(func=...) untuk mengaitkan fungsi dengan setiap subperintah. Kemudian, setelah parsing, kita memanggil fungsi yang sesuai jika ada.

2. Menumpuk Subperintah

Anda dapat menumpuk subperintah untuk membuat CLI yang lebih kompleks dan hierarkis. Misalnya, pertimbangkan CLI untuk mengelola sumber daya cloud:

cloud compute instance create --name my-instance --region us-east-1
cloud storage bucket list --project my-project

Dalam contoh ini, cloud adalah perintah utama, compute dan storage adalah subperintah, dan instance dan bucket adalah sub-subperintah.

3. Contoh Dunia Nyata: Alat Internasionalisasi

Bayangkan sebuah alat untuk mengelola terjemahan dalam aplikasi multi-bahasa. Anda dapat menggunakan subperintah untuk mengatur operasi yang berbeda:

translation tool add-language --code fr_FR --name "French (France)"
translation tool extract-strings --source-dir src
translation tool translate --target-language es_ES --source-file strings.pot

Pendekatan ini memungkinkan pemisahan perhatian yang jelas dan membuat alat lebih mudah digunakan dan dipelihara, terutama ketika berurusan dengan banyak bahasa dan alur kerja terjemahan yang berlaku di berbagai negara.

Kelas Aksi Kustom: Menyesuaikan Penguraian Argumen

argparse memungkinkan Anda untuk menentukan kelas aksi kustom untuk menyesuaikan cara argumen diproses. Ini berguna untuk skenario di mana perilaku pemrosesan argumen default tidak mencukupi. Kelas aksi adalah kelas yang mewarisi dari argparse.Action dan menggantikan metode __call__.

Membuat Kelas Aksi Kustom

Berikut adalah contoh kelas aksi kustom yang mengkonversi argumen menjadi huruf besar:

            
import argparse

class ToUpper(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if isinstance(values, list):
            setattr(namespace, self.dest, [v.upper() for v in values])
        else:
            setattr(namespace, self.dest, values.upper())

# Buat parser
parser = argparse.ArgumentParser(description='Contoh dengan aksi kustom')

# Tambahkan argumen dengan aksi kustom
parser.add_argument('--name', action=ToUpper, help='Nama yang akan dikonversi menjadi huruf besar')
parser.add_argument('--cities', action=ToUpper, nargs='+', help='Daftar kota yang akan dikonversi menjadi huruf besar')

# Uraikan argumen
args = parser.parse_args()

# Cetak hasilnya
if args.name:
    print(f'Nama: {args.name}')
if args.cities:
    print(f'Kota: {args.cities}')

            

              
                Copy
              
            
          

Dalam contoh ini:

• Kami mendefinisikan kelas ToUpper yang mewarisi dari argparse.Action.
• Metode __call__ dipanggil ketika argumen ditemukan. Diperlukan argumen berikut:
  • parser: Objek ArgumentParser.
  • namespace: Objek namespace tempat argumen yang diuraikan disimpan.
  • values: Nilai argumen.
  • option_string: String opsi yang digunakan untuk memanggil aksi ini (misalnya, --name).
• Di dalam metode __call__, kami mengkonversi nilai menjadi huruf besar menggunakan values.upper() dan menyimpannya dalam namespace menggunakan setattr(namespace, self.dest, values.upper()).
• Kami menambahkan argumen ke parser menggunakan parser.add_argument('--name', action=ToUpper, help='Nama yang akan dikonversi menjadi huruf besar'). Kami menentukan argumen action sebagai kelas aksi kustom kami.

Untuk menjalankan skrip ini, Anda akan menggunakan perintah seperti:

python your_script.py --name john
python your_script.py --cities london paris tokyo

Kasus Penggunaan untuk Kelas Aksi Kustom

1. Memvalidasi Input

Anda dapat menggunakan kelas aksi kustom untuk memvalidasi input dan menimbulkan kesalahan jika input tidak valid. Misalnya, Anda dapat membuat kelas aksi yang memeriksa apakah sebuah file ada atau apakah suatu angka berada dalam rentang tertentu.

            
import argparse
import os

class FileMustExist(argparse.Action):
    def __call__(self, parser, namespace, values, option_string=None):
        if not os.path.exists(values):
            raise argparse.ArgumentTypeError(f'File not found: {values}')
        setattr(namespace, self.dest, values)

parser = argparse.ArgumentParser(description='Contoh memvalidasi keberadaan file.')
parser.add_argument('--input-file', action=FileMustExist, help='Jalur ke file input.')

args = parser.parse_args()

print(f'File input: {args.input_file}')

            

              
                Copy
              
            
          

2. Mengkonversi Satuan

Anda dapat menggunakan kelas aksi kustom untuk mengkonversi satuan. Misalnya, Anda dapat membuat kelas aksi yang mengkonversi suhu dari Celsius ke Fahrenheit.

3. Menangani Struktur Data yang Kompleks

Jika Anda perlu menguraikan argumen menjadi struktur data yang kompleks (misalnya, kamus, daftar objek), Anda dapat menggunakan kelas aksi kustom untuk menangani logika penguraian.

4. Contoh: Menangani Zona Waktu

Pertimbangkan aplikasi yang perlu menangani tanggal dan waktu di zona waktu yang berbeda. Kelas aksi kustom dapat digunakan untuk menguraikan string tanggal dan mengkonversinya ke zona waktu tertentu menggunakan pustaka seperti pytz.

            
import argparse
import datetime
import pytz

class TimeZoneConverter(argparse.Action):
    def __init__(self, option_strings, dest, timezone=None, **kwargs):
        super().__init__(option_strings, dest, **kwargs)
        self.timezone = timezone

    def __call__(self, parser, namespace, values, option_string=None):
        try:
            dt = datetime.datetime.fromisoformat(values)
            if self.timezone:
                tz = pytz.timezone(self.timezone)
                dt = tz.localize(dt)
            setattr(namespace, self.dest, dt)
        except ValueError:
            raise argparse.ArgumentTypeError(f"Format tanggal/waktu tidak valid. Gunakan format ISO (YYYY-MM-DDTHH:MM:SS): {values}")
        except pytz.exceptions.UnknownTimeZoneError:
            raise argparse.ArgumentTypeError(f"Zona Waktu Tidak Valid: {self.timezone}")

parser = argparse.ArgumentParser(description='Contoh dengan konversi zona waktu.')
parser.add_argument('--event-time', action=TimeZoneConverter, timezone='America/Los_Angeles', help='Waktu acara dalam format ISO (YYYY-MM-DDTHH:MM:SS). Mengkonversi ke zona waktu America/Los_Angeles.')

args = parser.parse_args(['--event-time', '2024-10-27T10:00:00'])

print(f'Waktu Acara (Los Angeles): {args.event_time}')

            

              
                Copy
              
            
          

Contoh ini menunjukkan bagaimana aksi kustom dapat menangani konversi zona waktu menggunakan pustaka pytz, yang menunjukkan penggunaan yang lebih canggih yang relevan secara global.

Praktik Terbaik untuk Menggunakan Argparse Tingkat Lanjut

• Buat Sederhana: Jangan mempersulit CLI Anda. Gunakan subperintah dan aksi kustom hanya jika perlu.
• Sediakan Pesan Bantuan yang Jelas: Tulis pesan bantuan yang jelas dan ringkas untuk setiap perintah dan argumen. Gunakan argumen help di add_argument() secara ekstensif.
• Validasi Input: Selalu validasi input pengguna untuk mencegah kesalahan dan kerentanan keamanan.
• Gunakan Konvensi Penamaan yang Konsisten: Ikuti konvensi penamaan yang konsisten untuk perintah, argumen, dan opsi. Pertimbangkan untuk menggunakan kebab-case (--my-option) untuk nama opsi panjang.
• Uji Secara Menyeluruh: Uji CLI Anda secara menyeluruh dengan berbagai input dan skenario.
• Dokumentasikan CLI Anda: Berikan dokumentasi yang komprehensif untuk CLI Anda, termasuk contoh cara menggunakan setiap perintah dan argumen. Alat seperti Sphinx dapat menghasilkan dokumentasi dari kode Anda.
• Pertimbangkan Lokalisasi: Jika CLI Anda ditujukan untuk audiens global, pertimbangkan untuk melokalisasi pesan bantuan dan teks lain yang berhadapan dengan pengguna.

Kesimpulan

Subperintah dan kelas aksi kustom adalah alat yang ampuh untuk membuat CLI yang canggih dan ramah pengguna dengan argparse. Dengan menguasai fitur-fitur tingkat lanjut ini, Anda dapat membangun aplikasi baris perintah yang kuat, dapat dipelihara, dan terukur yang memenuhi kebutuhan berbagai basis pengguna. Dari mengelola aplikasi multi-bahasa hingga menangani zona waktu di seluruh dunia, kemungkinannya sangat luas. Rangkul teknik ini untuk meningkatkan skrip Python dan pengembangan alat baris perintah Anda ke tingkat berikutnya.